/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.folha.controller;

import br.com.folha.dao.CalculoFolhaDao;
import br.com.folha.dao.DiaSemanaDao;
import br.com.folha.dao.DisciplinaDao;
import br.com.folha.dao.DisponibilidadeDao;
import br.com.folha.dao.GenericoDao;
import br.com.folha.dao.GradeDao;
import br.com.folha.dao.ProfessorDao;
import br.com.folha.dao.TipoContratoDao;
import br.com.folha.dao.UnidadeDao;
import br.com.folha.entity.CalculoFolha;
import br.com.folha.entity.Disciplina;
import br.com.folha.entity.DisponibilidadeProfessor;
import br.com.folha.entity.GradeHorariaFp;
import br.com.folha.entity.Professor;
import br.com.folha.entity.TipoContrato;
import br.com.folha.entity.Unidade;
import br.com.folha.service.FolhaService;
import br.com.folha.service.GradeService;
import java.io.IOException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DateFormat;
import java.text.Format;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.TimeZone;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import javax.faces.model.SelectItem;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletResponse;
import net.sf.jasperreports.engine.JRDataSource;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import org.joda.time.DateTime;
import org.joda.time.Interval;
import org.joda.time.ReadableInterval;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

/**
 *
 * @author marceloml
 */
@ManagedBean(name = "CalculoFolhaController")
@ViewScoped
public final class CalculoFolhaController implements Serializable{
    
    private static final long serialVersionUID = 1L;
    
    private Unidade unidade;
    private Integer selectedUnidades;
    private UnidadeDao unidadeDao = new UnidadeDao();
    private GenericoDao calculoFolhaDao = new GenericoDao();
    
    private Date data = new Date();
    
    private GradeHorariaFp calculoFolha;
    private GradeHorariaFp gradeHorariaSelecionada;
    
    private DiaSemanaDao diaSemanaDao   = new DiaSemanaDao();
    private boolean retorno;
    private Date dataInicial;
    private Date dataFinal;
    
    private GradeService grade = new GradeService();    
    private List<CalculoFolha> retornoGrade;
    private Unidade unidadeCorrente;
    private String nomeUnidade;
    private CalculoFolhaDao consulta = new CalculoFolhaDao();    
    
    private transient DataModel lista;
    private Set<Unidade> unidadeUsuario;
    
    private Integer selectedTurma;
    
    private String horaIni;
    private String horaFim; 
    private String totHrs;     
    
    private Float valor;     
    
    private Date tmpHoraFim;                    
    
    private Integer filtroSelecionado;
    private Boolean exibeDatas;
    private String dataIniFiltro;
    private String dataFimFiltro;
    
    private Date dataAulaComparacao;
    private Date dataAtualComparacao;
        
    private boolean resultado;
    
    private String relDataIni;
    private String relDataFim;
    private Boolean consideraFds;
    
    private TipoContrato tipoContrato;
    private TipoContratoDao tipoContratoDao = new TipoContratoDao();  
    private Integer selectTipoContrato;
    
    private BigDecimal valorDesconto;
    private BigDecimal valorEmprestimo;        
    private List<Object> listaProfessores;
    private Integer selectedProfessor;
    private ProfessorDao professorDao = new ProfessorDao();
    
    private DisponibilidadeDao disponibilidadeDao = new DisponibilidadeDao();
    private List<Object> retornoGradeProfessor;
    private Double minutos = 0.00;
    private Double horas = 0.00;
    private Double totAtraso = 0.00;
    private Date horasAtraso = new Date();
    private Double totReceber = 0.00;
    private Float valorReceber = 0F;
    
    private String relatorio;
    private String tipoRecibo;
    private String tipoPonto;
    private Boolean pontoMes;
    private Boolean pontoPeriodo;    
    private Boolean reciboMes;
    private Boolean reciboPeriodo;
    private List<DisponibilidadeProfessor> listaDisponibilidade;
    private Date dataCalculada;
    private GradeHorariaFp folhaPagamento;
    private LoginController usuarioLogado;
    private GradeDao gradeDao;
    private Long retornoValidaProfessor;
    private String horaIniAnterior;
    private String horaFimAnterior;
    private Float totHoraAnterior;
    private Float totHoraAtual;
    private float atraso = 0F;
    private Double totHoras = 0.00;
    private List<DisponibilidadeProfessor> retornoDisponibilidade;
    private Integer selectedDisciplina;
    private DisciplinaDao disciplinaDao = new DisciplinaDao();
    private List<Disciplina> listaProfessorDisciplina;
    
    private Integer mesFiltro;
    private Integer mesFiltroPonto;
    private Integer selectedProfessorDisciplina;
    private String horasAReceber;
    private Disciplina disciplina;
    
    public CalculoFolhaController() throws ParseException{
        
        calculoFolha = new GradeHorariaFp();         
        selectedUnidades = 0;
        selectedProfessor = 0;
        filtroSelecionado = 0;        
        getExibeDatas();
        
    }        
    
    /*
     * Função utilizada pelo filtro por datas
     * onde é realizada a consulta das aulas da grade com os filtros passados pelo usuário
     * data inicial e data final
     */
    public void atualizaLista() {
        
      if(selectedUnidades != null && selectedUnidades != 0){
      
            if(filtroSelecionado == 1 && dataIniFiltro != null && !dataIniFiltro.equals("")){

              Calendar calendar = Calendar.getInstance(); // ou new GregorianCalendar  
              calendar.clear();  
              calendar.set(Calendar.YEAR,Integer.parseInt(this.dataIniFiltro.substring(6, 10)));
              calendar.set(Calendar.MONTH, Integer.parseInt(this.dataIniFiltro.substring(3, 5)) - 1);
              calendar.set(Calendar.DAY_OF_MONTH,Integer.parseInt(this.dataIniFiltro.substring(0, 2)));

              Calendar calendar2 = Calendar.getInstance(); // ou new GregorianCalendar  
              calendar2.clear();  
              calendar2.set(Calendar.YEAR,Integer.parseInt(this.dataFimFiltro.substring(6, 10)));
              calendar2.set(Calendar.MONTH, Integer.parseInt(this.dataFimFiltro.substring(3, 5)) - 1);
              calendar2.set(Calendar.DAY_OF_MONTH,Integer.parseInt(this.dataFimFiltro.substring(0, 2)));                                

              System.out.println("Data inicial Filtro :"+calendar.getTime());
              System.out.println("Data final Filtro :"+calendar2.getTime());
              
                  lista = new ListDataModel(consulta.consultaGrade(unidadeDao.getById(selectedUnidades),calendar.getTime(), calendar2.getTime()));                

            }

              unidadeCorrente = unidadeDao.getById(selectedUnidades);
              setNomeUnidade(unidadeCorrente.getNome());      
              getCarregarSelectProfessor();

              org.primefaces.context.RequestContext.getCurrentInstance().update("selectProfessor");    
        
      }else{
          
            FacesMessage msg = null;
          
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, "Você deve selecionar uma Unidade!", "");
            FacesContext.getCurrentInstance().addMessage(null, msg);                      
          
      }

    }  
    
    public void filtroPadrao() throws ParseException{
        
        if(filtroSelecionado == 0){
            
            getLista();            
            
        }
        
    }
    
    /*
     * Momento que é carregado o select com as unidades que o usuário logado pertence
     * para que o mesmo selecione de qual unidade deseja que a grade horária seja exibida
     */    
    public Collection<SelectItem>  getCarregarUnidadeDisponivel(){
        
        unidade = new Unidade();        
        LoginController usuarioLogado = new LoginController();        
        Collection<SelectItem> lst = new ArrayList<SelectItem>(); 
        lst.add(new SelectItem(null, "Selecione a Unidade"));      //Primeiro item do select 
        
        unidadeUsuario = usuarioLogado.Usuario.getUnidades();                
        
        for (Iterator iterator = usuarioLogado.Usuario.getUnidades().iterator(); iterator.hasNext();){            
            Unidade unidade = (Unidade) iterator.next();             
            
                lst.add(new SelectItem(unidade.getId(), unidade.getNome()));                                      
            
        }                
        
        return lst;                  
        
    }                      

    public DataModel getLista() throws ParseException {
        
       if(lista == null || lista.getRowCount() == 0){
           
                Calendar calendar = Calendar.getInstance(); // ou new GregorianCalendar  
                calendar.clear();  
                calendar.setTime(data);        

                dataInicial = grade.calculaDataAnterior(data, 1);                                
                
                 int dia = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
                 int mes = calendar.get(Calendar.MONTH)+1;
                 int ano = calendar.get(Calendar.YEAR);                    
                
                 SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy"); 
                 dataFinal = formato.parse( dia+"/"+mes+"/"+ano );                                                 

                 lista = new ListDataModel(consulta.consultaGrade(unidadeDao.getById(selectedUnidades),dataInicial, dataFinal));

        }                       
                       
        return lista;
    }        

    public void setLista(DataModel lista) {
        this.lista = lista;
    }

    public Boolean getExibeDatas() throws ParseException {
        if(filtroSelecionado == 0){
            exibeDatas = false;
            lista = null;
            getLista();
            dataIniFiltro = "";
            dataFimFiltro = "";
        }else{
            exibeDatas = true;
        }
        return exibeDatas;
    }

    public void setExibeDatas(Boolean exibeDatas) {
        this.exibeDatas = exibeDatas;
    }

    public void editar(){                

        Calendar calendar = Calendar.getInstance(); // ou new GregorianCalendar  
        calendar.clear();          
        calendar.setTime(this.gradeHorariaSelecionada.getData());                        
        System.out.println("calendar :"+calendar.getTime());
        
        Calendar calendar2 = Calendar.getInstance(); // ou new GregorianCalendar  
        calendar2.clear();          
        calendar2.setTime(data);
        System.out.println("calendars :"+calendar2.getTime());
        
        int mesAula  = calendar.get(Calendar.MONTH);
        int mesFolha = calendar2.get(Calendar.MONTH);
        int diaFolha = calendar2.get(Calendar.DAY_OF_MONTH);
        
        System.out.println("mesAula :"+mesAula);
        System.out.println("mesFolha :"+mesFolha);
        System.out.println("diaFolha :"+diaFolha);
        
        if((mesAula == mesFolha) || (mesAula == mesFolha - 1 || diaFolha <= 10)){
                        System.out.println("Estou no if");
                calculoFolha = this.gradeHorariaSelecionada;

                this.setSelectedDisciplina(calculoFolha.getDisciplina().getId());
                this.selectedProfessorDisciplina = calculoFolha.getProfessor().getId();

                getCarregarProfessor();

                //Tratamento para preencher com zeros a esquerda
                this.horaIni = this.horaIni.format("%02d", this.gradeHorariaSelecionada.getHoraIni().getHours()) + ":" + this.getHoraIni().format("%02d", this.gradeHorariaSelecionada.getHoraIni().getMinutes());
                this.horaFim = this.horaFim.format("%02d", this.gradeHorariaSelecionada.getHoraFim().getHours()) + ":" + this.getHoraFim().format("%02d", this.gradeHorariaSelecionada.getHoraFim().getMinutes());

                this.horaIniAnterior = this.horaIni.format("%02d", this.gradeHorariaSelecionada.getHoraIniOri().getHours()) + ":" + this.horaIniAnterior.format("%02d", this.gradeHorariaSelecionada.getHoraIniOri().getMinutes());
                this.horaFimAnterior = this.horaFim.format("%02d", this.gradeHorariaSelecionada.getHoraFimOri().getHours()) + ":" + this.horaFimAnterior.format("%02d", this.gradeHorariaSelecionada.getHoraFimOri().getMinutes());        
        
        }else{
            System.out.println("Estou no else");
            FacesMessage msg = null;
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, "Não será permitido alterar esta aula!", "");
            FacesContext.getCurrentInstance().addMessage(null, msg);                        
            
        }

   }  
    
    public void salvar() throws ParseException{
        
        FacesMessage msg = null;
        
        Calendar calendar = Calendar.getInstance(); // ou new GregorianCalendar  
        calendar.clear();          
        calendar.setTime(data);   
                
        calendar.set(Calendar.HOUR_OF_DAY,Integer.parseInt(horaIni.substring(0, 2)));        
        calendar.set(Calendar.MINUTE,Integer.parseInt(horaIni.substring(3, 5)));
        calendar.set(Calendar.SECOND,0);
                
        this.calculoFolha.setHoraIni(calendar.getTime());            
        
        Calendar calendar2 = Calendar.getInstance(); // ou new GregorianCalendar  
        calendar2.clear();          
        calendar2.setTime(data);   
                
        calendar2.set(Calendar.HOUR_OF_DAY,Integer.parseInt(horaFim.substring(0, 2)));        
        calendar2.set(Calendar.MINUTE,Integer.parseInt(horaFim.substring(3, 5)));
        calendar2.set(Calendar.SECOND,0);        
        
        this.calculoFolha.setHoraFim(calendar2.getTime());   
        
        SimpleDateFormat hr = new SimpleDateFormat("HH:mm");   
        String pattern = "HH:mm";  

        DateFormat df = new SimpleDateFormat(pattern);  
        Date horaIniNova = df.parse(this.horaIni);        
        Date horaFimNova = df.parse(this.horaFim);         
        
        FolhaService folhaService = new FolhaService();
        this.valor = folhaService.getValor(this.calculoFolha.getProfessor(), this.calculoFolha.getUnidade(), this.calculoFolha.getTurma(), hr.parse(hr.format(horaIniNova)), hr.parse(hr.format(horaFimNova)));
        
        this.calculoFolha.setValor(BigDecimal.valueOf(this.valor));
        
        this.totHoraAnterior = folhaService.getTempo(df.parse(this.horaIniAnterior), df.parse(this.horaFimAnterior));
        
        this.totHoraAtual   = folhaService.getTempo(horaIniNova, horaFimNova);
        
        calendar2.clear();          
        calendar2.setTime(data);                           

            this.atraso = (this.totHoraAnterior - this.totHoraAtual) * 60;
            Integer i = new Integer(Math.round(this.atraso));
            
            calendar2.clear();
            calendar2.setTime(data);  
            calendar2.set(Calendar.HOUR_OF_DAY,0);        
            calendar2.set(Calendar.MINUTE,i);
            calendar2.set(Calendar.SECOND,0);              
            
            this.calculoFolha.setAtraso(calendar2.getTime());
              
            this.calculoFolha.setProfessor(professorDao.getById(selectedProfessorDisciplina));
            this.calculoFolha.setDisciplina(disciplinaDao.getById(selectedDisciplina));
        
        retorno = calculoFolhaDao.atualizar(this.calculoFolha);
        
        if(retorno){                   
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO, "Apontamento atualizado com sucesso!", "");
            FacesContext.getCurrentInstance().addMessage(null, msg);
            
            resetaCampos();
            
        }else{
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, "Falha ao atualizar Apontamento!", "");
            FacesContext.getCurrentInstance().addMessage(null, msg);            
        }         
        
    }
    
    /*
     * Geração do relatorio
     */
    
    public void relatorioRecibos() throws IOException, ParseException{    

    if(selectedProfessor != 0){
        
                totHoras   = 0.00;
                totAtraso  = 0.00; 
                horasAtraso = new Date();
                totReceber = 0.00;
                minutos    = 0.00;
                horas      = 0.00;
                valorReceber = 0F;
                
                String mesExtenso = "";
                Date periodoInicial = new Date();
                Date periodoFinal   = new Date();
        
                Locale brasil = new Locale("pt", "BR");
                Calendar calendar = Calendar.getInstance(brasil); // ou new GregorianCalendar  
                calendar.clear();      
                
                Calendar calendar2 = Calendar.getInstance(); // ou new GregorianCalendar  
                calendar2.clear();                 
        
        //Bloco utilizado para quando o relatório de recibos for gerado por mês
        if(tipoRecibo.equals("mes")){
            
                Calendar calendar3 = Calendar.getInstance(); // ou new GregorianCalendar  
                calendar3.clear(); 
                calendar3.setTime(data);
                calendar3.set(Calendar.MONTH, mesFiltro);
                
            int ultimoDia = calendar3.getActualMaximum(Calendar.DAY_OF_MONTH);
            int primeiroDia = calendar3.getActualMinimum(Calendar.DAY_OF_MONTH);                 
            int mes = calendar3.get(Calendar.MONTH);
            int ano = calendar3.get(Calendar.YEAR);
            
                calendar.set(Calendar.YEAR,ano);
                calendar.set(Calendar.MONTH, mesFiltro);
                calendar.set(Calendar.DAY_OF_MONTH,primeiroDia);
                
                TimeZone tz = TimeZone.getTimeZone("GMT-3");
                calendar.setTimeZone(tz);                
 
                calendar2.set(Calendar.YEAR,ano);
                calendar2.set(Calendar.MONTH, mesFiltro);
                calendar2.set(Calendar.DAY_OF_MONTH,ultimoDia); 
                
                Format formatter;                
                formatter = new SimpleDateFormat("MMMM");    
                mesExtenso = formatter.format(calendar.getTime());                
                
                System.out.println("Mes :"+mesExtenso);
                
        }else{            

                calendar.set(Calendar.YEAR,Integer.parseInt(this.relDataIni.substring(6, 10)));
                calendar.set(Calendar.MONTH, Integer.parseInt(this.relDataIni.substring(3, 5)) - 1);
                calendar.set(Calendar.DAY_OF_MONTH,Integer.parseInt(this.relDataIni.substring(0, 2)));  
                
                periodoInicial = calendar.getTime();

                calendar2.set(Calendar.YEAR,Integer.parseInt(this.relDataFim.substring(6, 10)));
                calendar2.set(Calendar.MONTH, Integer.parseInt(this.relDataFim.substring(3, 5)) - 1);
                calendar2.set(Calendar.DAY_OF_MONTH,Integer.parseInt(this.relDataFim.substring(0, 2)));                          
                
                periodoFinal = calendar2.getTime();
            
        }
        
                FolhaService folhaService = new FolhaService();
                
                if(selectTipoContrato == 1 || selectTipoContrato == 2){                                         

                System.out.println("selectTipoContrato :"+selectTipoContrato);
                System.out.println("selectedProfessor :"+selectedProfessor);
                System.out.println("calendar.getTime() :"+calendar.getTime());
                System.out.println("calendar2.getTime() :"+calendar2.getTime());
                    
                     retornoGradeProfessor = consulta.listaGradeProfessor(unidadeDao.getById(selectedUnidades), selectTipoContrato, selectedProfessor, consideraFds, calendar.getTime(), calendar2.getTime());
                     System.out.println("*****retornoGradeProfessor :"+retornoGradeProfessor.size());
                     for (Iterator iterator = retornoGradeProfessor.iterator(); iterator.hasNext();){            
                         
                         GradeHorariaFp folha = (GradeHorariaFp) iterator.next();
                         
                         minutos = minutos + folha.getAtraso().getMinutes();
                         horas   = horas + folha.getAtraso().getHours();                                                 
                         
                     }                     
                     //Calculo utilizado para converter minutos em fração e horas
                     minutos =  minutos / 60;
                     totAtraso = horas + minutos;                                              
                     System.out.println("totAtraso :"+totAtraso);
                     retornoDisponibilidade = disponibilidadeDao.listaDisponibilidadeProfessor(selectedProfessor, selectedUnidades, selectTipoContrato);
                     
                     for (Iterator iterator = retornoDisponibilidade.iterator(); iterator.hasNext();){            
                         
                         DisponibilidadeProfessor disponibilidade = (DisponibilidadeProfessor) iterator.next();
                         totHoras = totHoras + folhaService.getTempo(disponibilidade.getHora_ini(), disponibilidade.getHora_fim());                         
                     }
                
                }else{
                    
                     retornoGradeProfessor = consulta.listaGradeProfessor(unidadeDao.getById(selectedUnidades), selectTipoContrato, selectedProfessor, consideraFds, calendar.getTime(), calendar2.getTime());
                     
                     for (Iterator iterator = retornoGradeProfessor.iterator(); iterator.hasNext();){            
                         
                         GradeHorariaFp folha = (GradeHorariaFp) iterator.next();
                         
                        Calendar calendar3 = Calendar.getInstance(); // ou new GregorianCalendar  
                        calendar3.clear();     
                        calendar3.setTime(folha.getData());                                                
                         
                        List<DisponibilidadeProfessor> retornoDispo = disponibilidadeDao.consultaDisponibilidadeProfessorDia(folha.getProfessor(), diaSemanaDao.getById(calendar3.get(Calendar.DAY_OF_WEEK)));
                        
                        if(retornoDispo.isEmpty()){
                            
                            Float horasAula = folhaService.getTempo(folha.getHoraIni(), folha.getHoraFim());
                            
                            valorReceber = valorReceber + folhaService.getValorHoras(folha.getProfessor(), unidadeDao.getById(selectedUnidades), folha.getTurma(), horasAula);
                            
                            totHoras = totHoras + folhaService.getTempo(folha.getHoraIni(), folha.getHoraFim());
                            
                        }else{

                            DateTimeFormatter formatador = DateTimeFormat.forPattern("HH:mm");                               
                            
                            for(Iterator iterator2 = retornoDispo.iterator(); iterator2.hasNext();){

                                DisponibilidadeProfessor disponibilidade = (DisponibilidadeProfessor) iterator2.next();
                                
                                SimpleDateFormat hr = new SimpleDateFormat("HH:mm");   
                                String pattern = "HH:mm";  

                                DateFormat df = new SimpleDateFormat(pattern);                                                                    
                                
                                DateTime beforeDate = formatador.parseDateTime(df.format(folha.getHoraIni()));  
                                DateTime afterDate = formatador.parseDateTime(df.format(folha.getHoraFim()));  
                                DateTime deDateVer = formatador.parseDateTime(df.format(disponibilidade.getHora_ini()));  
                                DateTime ateDateVer = formatador.parseDateTime(df.format(disponibilidade.getHora_fim()));
                                
                                Interval interval = new Interval(beforeDate, afterDate);  
                                Interval interval2 = new Interval(deDateVer, ateDateVer);                                  

                                ReadableInterval readableInterval = interval2;                                                                         
                                
                                if(interval.overlap(readableInterval) != null){                                                                        
                                    
                                    Float horasAula = folhaService.horasAvulsas(df.parse(df.format(folha.getHoraIni())), df.parse(df.format(folha.getHoraFim())), df.parse(df.format(disponibilidade.getHora_ini())), df.parse(df.format(disponibilidade.getHora_fim())));

                                    valorReceber = valorReceber + folhaService.getValorHoras(folha.getProfessor(), unidadeDao.getById(selectedUnidades), folha.getTurma(), horasAula);
                                    
                                    totHoras = totHoras + folhaService.horasAvulsas(df.parse(df.format(folha.getHoraIni())), df.parse(df.format(folha.getHoraFim())), df.parse(df.format(disponibilidade.getHora_ini())), df.parse(df.format(disponibilidade.getHora_fim())));
                                    
                                    int horas = (int) Math.round(totHoras);
                                    
                                    double minutos = totHoras - ((double) horas);
                                    minutos = (minutos * 60) /100;
                                    
                                    double horasMinutos = (double) horas + minutos;
                                    
                                    NumberFormat format = NumberFormat.getInstance();  
                                    format.setMaximumFractionDigits(3);  
                                    format.setMinimumFractionDigits(2);  
                                    format.setMaximumIntegerDigits(3);                                        
                                    
                                    totHoras = Double.valueOf(format.format(horasMinutos).replace(",", "."));                                    
                                    
                                }//Fim da validação se as horas da aula estão contidas nas horas disponiveis

                            }//Fim do For de consulta a disponibilidade                                                        
                        
                        }                                                
                         
                     }                                         
                    
                }
                
                /*
                 * Cálculo necessário pois os professores não recebem pela quantidade de semanas no mês
                 * mas sim, considerando 4,5 semanas sempre
                 */                                                                  
                                 
                if(selectTipoContrato == 1 || selectTipoContrato == 2){
                    totHoras = totHoras * 4.5;                                       
                    
                    totReceber = totHoras  - totAtraso; 
                    valorReceber = folhaService.getValorReceber(selectedProfessor, unidadeDao.getById(selectedUnidades), totReceber.floatValue());
                }                                              
                
                System.out.println("TotAtraso2 :"+totAtraso);
                System.out.println("totHoras :"+totHoras);
                System.out.println("totReceber :"+totReceber);                
                
                HashMap params = new HashMap();
                
                /*
                 * Blocos necessários para converter a fração de horas necessária para os calculos,
                 * em horas e minutos para melhor visualização no relatório
                 */
                
                if(totAtraso > 0.00){
                    
                    System.out.println("1º If");
                                    
                        if(totAtraso < 1.00){

                            Calendar horasAtrasoConv = Calendar.getInstance(); // ou new GregorianCalendar  
                            horasAtrasoConv.clear();                            
                            horasAtrasoConv.set(Calendar.HOUR,0);        
                            horasAtrasoConv.set(Calendar.MINUTE,(int)(totAtraso * 60));
                            horasAtrasoConv.set(Calendar.SECOND,0); 

                            SimpleDateFormat hr = new SimpleDateFormat("HH:mm");   
                            String pattern = "HH:mm";  

                            DateFormat df = new SimpleDateFormat(pattern);  
                            Date horasAtrasoConv2 = horasAtrasoConv.getTime();
                            System.out.println("Horas Atraso If :"+horasAtrasoConv.getTime());
                            System.out.println("Horas Atraso If :"+horasAtrasoConv2.getTime());

                            if(selectTipoContrato != 99){
                                horasAtraso = df.parse(df.format(horasAtrasoConv2));
                            }                        
                            
                            int valorHora = totReceber.intValue();
                            Double valorMinuto = (valorHora - totReceber) * 60;

                            if(valorMinuto < 0.00){
                                valorMinuto = valorMinuto * (-1);
                            }                    

                            String horasAtrasoConv3 = valorHora+"."+valorMinuto.intValue();                    

                            horasAReceber = horasAtrasoConv3;                   

                        }else{

                            int valorHora = totAtraso.intValue();
                            Double valorMinuto = (valorHora - totAtraso) * 60;

                            if(valorMinuto < 0.00){
                                valorMinuto = valorMinuto * (-1);
                            }

                            Calendar horasAtrasoConv = Calendar.getInstance(); // ou new GregorianCalendar  
                            horasAtrasoConv.clear();
                            horasAtrasoConv.setTime(data);  
                            horasAtrasoConv.set(Calendar.HOUR_OF_DAY,valorHora);        
                            horasAtrasoConv.set(Calendar.MINUTE,(int)Math.round(valorMinuto));
                            horasAtrasoConv.set(Calendar.SECOND,0); 

                            SimpleDateFormat hr = new SimpleDateFormat("HH:mm");   
                            String pattern = "HH:mm";  

                            DateFormat df = new SimpleDateFormat(pattern);  
                            Date horasAtrasoConv2 = horasAtrasoConv.getTime();                                                             

                            horasAtraso = df.parse(df.format(horasAtrasoConv2));
                            System.out.println("Horas Atraso If :"+horasAtraso);
                            valorHora = totReceber.intValue();
                            valorMinuto = (valorHora - totReceber) * 60;

                            if(valorMinuto < 0.00){
                                valorMinuto = valorMinuto * (-1);
                            }                    

                            String horasAtrasoConv3 = valorHora+"."+valorMinuto.intValue();                    

                            horasAReceber = horasAtrasoConv3;                    

                        }    
                
                }else{
                    System.out.println("2º If");
                    horasAReceber = totHoras.toString();
                    horasAtraso.setHours(0);
                    horasAtraso.setMinutes(0);
                }
                System.out.println("horasAtraso :"+horasAtraso);
                params.put("desconto",  valorDesconto);
                params.put("acrescimo", valorEmprestimo);
                params.put("tipoContrato", selectTipoContrato);
                params.put("tipoRecibo",tipoRecibo);
                params.put("mes",mesExtenso);
                params.put("periodoInicial",periodoInicial);
                params.put("periodoFinal",periodoFinal);
                params.put("valor", BigDecimal.valueOf(valorReceber.doubleValue())); 
                params.put("totHoras", totHoras);
                params.put("totAtraso", horasAtraso);
                params.put("totHorasReceber", horasAReceber);                                                

                JRDataSource jrds = null;

                if(consideraFds){               
                    jrds = new JRBeanCollectionDataSource(retornoGradeProfessor);

                /*Caso o usuário opte por não gerar os fins de semana no relatório
                 * a Lista de objetos deverá ser varrida afim de tirar as aulas que o professor
                 * deu nos fins de semana, dessa forma só imprimindo as aulas 
                 * dadas em dias de semana.
                 */  
                }else{

                    List<Object> listGrade2 = new ArrayList<Object>();

                    for (Iterator iterator = retornoGradeProfessor.iterator(); iterator.hasNext();){            
                        GradeHorariaFp folha = (GradeHorariaFp) iterator.next();                            
                        
                        Calendar calendar3 = Calendar.getInstance(); // ou new GregorianCalendar  
                        calendar3.clear();     
                        calendar3.setTime(folha.getData());
                        
                        if(calendar3.get(Calendar.DAY_OF_WEEK) != 7 && calendar3.get(Calendar.DAY_OF_WEEK) != 1){

                            listGrade2.add(folha);

                        }

                    } 
                    System.out.println("ListaGrade :"+listGrade2.size());
                    jrds = new JRBeanCollectionDataSource(listGrade2);

                }                

                resetaCamposRel();
                
                try{
                    
                    FacesContext context = FacesContext.getCurrentInstance();    
                    ServletContext servletContext = (ServletContext) context.getExternalContext().getContext();    
                    String caminhoRelatorio = servletContext.getRealPath("relatorios/recibos.jasper");    
                    System.out.println("caminhoRelatorio :"+caminhoRelatorio);
                    HttpServletResponse response = (HttpServletResponse) context.getExternalContext().getResponse();    
                    response.setContentType("application/pdf");    
                    response.addHeader("Content-disposition", "attachment; filename=\"Recibo - "+professorDao.getById(selectedProfessor).getNome() +".pdf\"");    
                    JasperPrint impressao = JasperFillManager.fillReport(caminhoRelatorio, params, jrds);    
                    System.out.println("impressao :"+impressao);
                    JasperExportManager.exportReportToPdfStream(impressao, response.getOutputStream());                        
                    
                    context.getApplication().getStateManager().saveView(context);    
                    context.renderResponse();
                    context.responseComplete();                                                            
                    
                }catch(Exception e){
                    
                }finally{
                    resetaCamposRel();
                    
                }                
    
    }else{
        
       FacesMessage msg = null;
       FacesContext context = FacesContext.getCurrentInstance();
        
       msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, "É necessáro informar o professor!", "");
       context.getCurrentInstance().addMessage(null, msg);                               
        
    }
     

    }    
    
    public void relatorioFolhaPonto() throws IOException{                           
                
                HashMap params = new HashMap();                                

                List<Object> listGrade = new ArrayList<Object>();  

                Locale brasil = new Locale("pt", "BR");
                Calendar calendar  = Calendar.getInstance(brasil); // ou new GregorianCalendar                  
                Calendar calendar2 = Calendar.getInstance(brasil); // ou new GregorianCalendar 
                String mesExtenso = "";
                
                if(tipoPonto.equals("mes")){
                    
                Calendar calendar3 = Calendar.getInstance(brasil); // ou new GregorianCalendar  
                calendar3.clear(); 
                calendar3.setTime(data);
                calendar3.set(Calendar.MONTH, mesFiltroPonto);                    

                int ultimoDia = calendar3.getActualMaximum(Calendar.DAY_OF_MONTH);
                int primeiroDia = calendar3.getActualMinimum(Calendar.DAY_OF_MONTH);                 
                int mes = calendar3.get(Calendar.MONTH);
                int ano = calendar3.get(Calendar.YEAR);

                calendar.set(Calendar.YEAR,ano);
                calendar.set(Calendar.MONTH, mesFiltroPonto);
                calendar.set(Calendar.DAY_OF_MONTH,primeiroDia);                             

                        calendar2.set(Calendar.YEAR,ano);
                        calendar2.set(Calendar.MONTH, mesFiltroPonto);
                        calendar2.set(Calendar.DAY_OF_MONTH,ultimoDia);
                        
                        System.out.println("Calendar :"+calendar.getTime());
                        System.out.println("Calendar2 :"+calendar2.getTime());

                        Format formatter;                
                        formatter = new SimpleDateFormat("MMMM");    
                        mesExtenso = formatter.format(calendar.getTime());                    
                    
                }else{

                        calendar.clear();  
                        calendar.set(Calendar.YEAR,Integer.parseInt(this.relDataIni.substring(6, 10)));
                        calendar.set(Calendar.MONTH, Integer.parseInt(this.relDataIni.substring(3, 5)) - 1);
                        calendar.set(Calendar.DAY_OF_MONTH,Integer.parseInt(this.relDataIni.substring(0, 2)));  
                        
                        calendar2.clear();  
                        calendar2.set(Calendar.YEAR,Integer.parseInt(this.relDataFim.substring(6, 10)));
                        calendar2.set(Calendar.MONTH, Integer.parseInt(this.relDataFim.substring(3, 5)) - 1);
                        calendar2.set(Calendar.DAY_OF_MONTH,Integer.parseInt(this.relDataFim.substring(0, 2)));
                
                }
                
                params.put("tipoPonto",tipoPonto);
                params.put("mes",mesExtenso);
                params.put("periodoInicial",calendar.getTime());
                params.put("periodoFinal",calendar2.getTime());            
                
                System.out.println("Tipo de Contrato :"+selectTipoContrato);               
                
                listGrade = consulta.listaGradePf(unidadeDao.getById(selectedUnidades), selectTipoContrato, consideraFds, calendar.getTime(), calendar2.getTime());

                JRDataSource jrds = null;

                if(consideraFds){               
                    jrds = new JRBeanCollectionDataSource(listGrade);

                /*Caso o usuário opte por não gerar os fins de semana no relatório
                 * a Lista de objetos deverá ser varrida afim de tirar as aulas que o professor
                 * deu nos fins de semana, dessa forma só imprimindo as aulas 
                 * dadas em dias de semana.
                 */  
                }else{

                    List<Object> listGrade2 = new ArrayList<Object>();

                    for (Iterator iterator = listGrade.iterator(); iterator.hasNext();){            
                        GradeHorariaFp folha = (GradeHorariaFp) iterator.next();                            

                        Calendar calendar3 = Calendar.getInstance(); // ou new GregorianCalendar  
                        calendar3.clear();     
                        calendar3.setTime(folha.getData());

                        if(calendar3.get(Calendar.DAY_OF_WEEK) != 7 && calendar3.get(Calendar.DAY_OF_WEEK) != 1){

                            listGrade2.add(folha);

                        }

                    } 

                    jrds = new JRBeanCollectionDataSource(listGrade2);

                }                
                                
                try{
                    
                    FacesContext context = FacesContext.getCurrentInstance();    
                    ServletContext servletContext = (ServletContext) context.getExternalContext().getContext();    
                    String caminhoRelatorio = servletContext.getRealPath("relatorios/folhaPonto.jasper");    
                    System.out.println("caminhoRelatorio :"+caminhoRelatorio);
                    HttpServletResponse response = (HttpServletResponse) context.getExternalContext().getResponse();    
                    response.setContentType("application/pdf");    
                    response.addHeader("Content-disposition", "attachment; filename=\"FolhaPonto.pdf\"");    
                    JasperPrint impressao = JasperFillManager.fillReport(caminhoRelatorio, params, jrds);    
                    System.out.println("impressao :"+impressao);
                    JasperExportManager.exportReportToPdfStream(impressao, response.getOutputStream());                        
                    
                    context.getApplication().getStateManager().saveView(context);    
                    context.renderResponse();
                    context.responseComplete();                                                            
                    
                }catch(Exception e){
                    
                }finally{
                    resetaCamposRel();
                    
                }
     
    }      
    
    public void resetaCampos(){
        
        this.horaFim = "";
        this.horaIni = "";
        this.selectedProfessorDisciplina = 0;
        this.setSelectedDisciplina((Integer) 0);
        
        calculoFolha = new GradeHorariaFp();
        
    }
    
    public void resetaCamposRel(){
        
        this.relDataIni = "";
        this.relDataFim = "";
        this.consideraFds = false;
        
    }
    
    public void executaRelatorio(){
        
        if(relatorio.equals("recibo")){
            
            org.primefaces.context.RequestContext.getCurrentInstance().execute("relatorioRecibos.show();");
            
        }
        
        if(relatorio.equals("folhaPonto")){
            
                org.primefaces.context.RequestContext.getCurrentInstance().execute("relatorioFolhaPonto.show();");
                
        }
        
    }
    
    public void completaFolha(){
        
        FacesMessage msg = null;          
        folhaPagamento = new GradeHorariaFp();
        usuarioLogado  = new LoginController();  
        gradeDao       = new GradeDao();
        
        try{
            Locale brasil = new Locale("pt", "BR");
            Calendar calendar = Calendar.getInstance(brasil); // ou new GregorianCalendar  
            calendar.clear();  
            calendar.setTime(data);                                     
            
            int ultimoDia = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
            int primeiroDia = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);                 
            int mes = calendar.get(Calendar.MONTH);
            int ano = calendar.get(Calendar.YEAR);                      
                            
            calendar.clear();  
            calendar.setTime(data);   
            calendar.clear();  
            calendar.set(Calendar.YEAR,ano);
            calendar.set(Calendar.MONTH, mes);
            calendar.set(Calendar.DAY_OF_MONTH,primeiroDia);            
            
            Calendar calendar2 = Calendar.getInstance(); // ou new GregorianCalendar  
            calendar2.clear();  
            calendar2.set(Calendar.YEAR,ano);
            calendar2.set(Calendar.MONTH, mes);
            calendar2.set(Calendar.DAY_OF_MONTH,ultimoDia);                          

            listaDisponibilidade =  disponibilidadeDao.listaDisponibilidadeUnidade(selectedUnidades);
                                 
                 FolhaService folhaService = new FolhaService();                
                 
                 for(int j = 0; j < listaDisponibilidade.size(); j++) {
                     
                 Calendar calendar3 = Calendar.getInstance(); // ou new GregorianCalendar  
                 calendar3.clear();  
                 calendar3.setTime(calendar.getTime());                                      
                 
                     while ((calendar3.getTime().before(calendar2.getTime()) || calendar3.getTime().equals(calendar2.getTime())) && (calendar3.getTime().after(calendar.getTime()) || calendar3.getTime().equals(calendar.getTime()) )) {

                        dataCalculada  = grade.calculaData(calendar3.getTime(), listaDisponibilidade.get(j).getDiaSemana().getId());

                            if(calendar3.get(Calendar.DAY_OF_WEEK) == listaDisponibilidade.get(j).getDiaSemana().getId()){
                                
                                       retornoValidaProfessor = gradeDao.consultaAulaProfessor(professorDao.getById(listaDisponibilidade.get(j).getProfessor()), calendar3.getTime(), listaDisponibilidade.get(j).getHora_ini(), listaDisponibilidade.get(j).getHora_fim());

                                       if(retornoValidaProfessor == 0){
                                           
                                        calendar2.clear();
                                        calendar2.setTime(data);  
                                        calendar2.set(Calendar.HOUR_OF_DAY,0);        
                                        calendar2.set(Calendar.MINUTE,0);
                                        calendar2.set(Calendar.SECOND,0);                                              
                                         
                                            folhaPagamento.setTurma(null);                    
                                            folhaPagamento.setDisciplina(null);
                                            folhaPagamento.setProfessor(professorDao.getById(listaDisponibilidade.get(j).getProfessor()));
                                            folhaPagamento.setUnidade(unidadeDao.getById(selectedUnidades));
                                            folhaPagamento.setHoraIniOri(listaDisponibilidade.get(j).getHora_ini());
                                            folhaPagamento.setHoraFimOri(listaDisponibilidade.get(j).getHora_fim());                                            
                                            folhaPagamento.setHoraIni(listaDisponibilidade.get(j).getHora_ini());
                                            folhaPagamento.setHoraFim(listaDisponibilidade.get(j).getHora_fim());
                                            folhaPagamento.setAtraso(calendar2.getTime());
                                            folhaPagamento.setTipoContrato(listaDisponibilidade.get(j).getTipoContrato().getId());                                                                              
                                            folhaPagamento.setData(calendar3.getTime());
                                            folhaPagamento.setDt_atualizacao(data);
                                            folhaPagamento.setUsuario_atualizacao(usuarioLogado.getUsuario().getId());

                                            Float minutos = folhaService.getTempo(folhaPagamento.getHoraIni(), folhaPagamento.getHoraFim());
                                            Float valorAula = folhaService.getValorReceber(folhaPagamento.getProfessor().getId(), unidadeDao.getById(selectedUnidades), minutos);
                                            folhaPagamento.setValor(BigDecimal.valueOf(valorAula));
                                            
                                            resultado = calculoFolhaDao.salvar(folhaPagamento);
                                       
                                       }
                                
                            }
                                
                                calendar3.add(Calendar.DATE,1);
                     
                    }
                     
                     calendar3.clear();
                     calendar3.setTime(calendar.getTime());  

                 }
                 
                 if(resultado){
                     
                Format formatter;                
                formatter = new SimpleDateFormat("MMMM");    
                String mesExtenso = formatter.format(calendar.getTime());                      
                     
                        msg = new FacesMessage(FacesMessage.SEVERITY_INFO, "Folha Completa para o mês de "+mesExtenso, "");
                        FacesContext.getCurrentInstance().addMessage(null, msg);                                                 
                     
                 }
            
        }catch(Exception e){
            
              msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, "Falha ao gerar grade "+e.getMessage(), "");
              FacesContext.getCurrentInstance().addMessage(null, msg);                          
            
        }
        
    }    

    public GradeHorariaFp getCalculoFolha() {
        return calculoFolha;
    }

    public void setCalculoFolha(GradeHorariaFp calculoFolha) {
        this.calculoFolha = calculoFolha;
    }

    public GradeHorariaFp getGradeHorariaSelecionada() {
        return gradeHorariaSelecionada;
    }

    public void setGradeHorariaSelecionada(GradeHorariaFp gradeHorariaSelecionada) {
        this.gradeHorariaSelecionada = gradeHorariaSelecionada;
    }

    public String getHoraIni() {
        return horaIni;
    }

    public void setHoraIni(String horaIni) {
        this.horaIni = horaIni;
    }

    public String getRelDataIni() {
        return relDataIni;
    }

    public void setRelDataIni(String relDataIni) {
        this.relDataIni = relDataIni;
    }

    public String getRelDataFim() {
        return relDataFim;
    }

    public void setRelDataFim(String relDataFim) {
        this.relDataFim = relDataFim;
    }

    public Boolean getConsideraFds() {
        return consideraFds;
    }

    public void setConsideraFds(Boolean consideraFds) {
        this.consideraFds = consideraFds;
    }
    
    public String getDataIniFiltro() {
        return dataIniFiltro;
    }

    public void setDataIniFiltro(String dataIniFiltro) {
        this.dataIniFiltro = dataIniFiltro;
    }

    public String getDataFimFiltro() {
        return dataFimFiltro;
    }

    public void setDataFimFiltro(String dataFimFiltro) {
        this.dataFimFiltro = dataFimFiltro;
    }    
    
    public String getTotHrs() {
        return totHrs;
    }

    public void setTotHrs(String totHrs) {
        this.totHrs = totHrs;
    }
    
    public Float getValor() {
        return valor;
    }

    public void setValor(Float valor) {                                   
        this.valor = valor;
    }

    public String getHoraFim() {
        return horaFim;
    }

    public void setHoraFim(String horaFim) {
        this.horaFim = horaFim;
    }

    public Integer getFiltroSelecionado() {
        return filtroSelecionado;
    }

    public void setFiltroSelecionado(Integer filtroSelecionado) {
        this.filtroSelecionado = filtroSelecionado;
    }    
    
    public Integer getSelectedUnidades() {
        return selectedUnidades;
    }

    public void setSelectedUnidades(Integer selectedUnidades) {
        this.selectedUnidades = selectedUnidades;
    }

    public String getNomeUnidade() {
        return nomeUnidade;
    }

    public void setNomeUnidade(String nomeUnidade) {
        this.nomeUnidade = nomeUnidade;
    }    

    public TipoContrato getTipoContrato() {
        return tipoContrato;
    }

    public void setTipoContrato(TipoContrato tipoContrato) {
        this.tipoContrato = tipoContrato;
    }
    
    public Collection<SelectItem> getCarregarTipoContrato() {                                      

          tipoContrato = new TipoContrato();

          Collection<SelectItem> lst = new ArrayList<SelectItem>();        
          lst.add(new SelectItem(0, "Todos os Tipos de Contratação"));      //Primeiro item do select   
          lst.add(new SelectItem(99, "Excedente"));
          List<TipoContrato> lista = tipoContratoDao.listaTipoContrato(tipoContrato);          
          for (int i = 0; i < lista.size(); i++) {                                  
              lst.add(new SelectItem(lista.get(i).getId(), lista.get(i).getDescricao()));              
          }          
          return lst;    

      } 
    
  public Collection<SelectItem> getCarregarProfessor() {
        
        Collection<SelectItem> lst = new ArrayList<SelectItem>();        
        lst.add(new SelectItem(null, "Selecione o Professor"));      //Primeiro item do select                          
                 
       if(getSelectedDisciplina() != null && getSelectedDisciplina() != 0){
            
            listaProfessorDisciplina = disciplinaDao.listaDisciplinaProfessor("p", getSelectedDisciplina());        
            
            if(!listaProfessorDisciplina.isEmpty()){
                
                for(Iterator iterator = listaProfessorDisciplina.get(0).getProfessores().iterator(); iterator.hasNext();){
                    
                    Professor professor = (Professor) iterator.next();                                        
                        
                        lst.add(new SelectItem(professor.getId(), professor.getNome()));              
                    
                }
                
            }
            
        } 
        
        return lst;          
    }    
  
  public Collection<SelectItem> getCarregarSelectDisciplina() {        
      
        disciplina = new Disciplina();
      
        Collection<SelectItem> lst = new ArrayList<SelectItem>();        
        lst.add(new SelectItem(null, "Selecione a Disciplina"));      //Primeiro item do select 
        
        if(selectedProfessorDisciplina == null || selectedProfessorDisciplina == 0){
            
            List<Disciplina> listaDisciplina = disciplinaDao.listaDisciplina(disciplina);

            for (int i = 0; i < listaDisciplina.size(); i++) {          
                lst.add(new SelectItem(listaDisciplina.get(i).getId(), listaDisciplina.get(i).getNome()));              
            }
            
        }else{
            
            List<Disciplina> listaDisciplina = disciplinaDao.listaDisciplinaProfessor("d", selectedProfessorDisciplina);

            for (int i = 0; i < listaDisciplina.size(); i++) {          
                lst.add(new SelectItem(listaDisciplina.get(i).getId(), listaDisciplina.get(i).getNome()));              
            }            
            
        }
                
        return lst;          
    }  
    
public Collection<SelectItem> getCarregarSelectProfessor() {
        
        Collection<SelectItem> lst = new ArrayList<SelectItem>();        
        lst.add(new SelectItem(null, "Selecione o Professor"));      //Primeiro item do select           
                
                listaProfessores = professorDao.listaProfessorAtivoUnidade(unidadeDao.getById(selectedUnidades));
                
                for(Iterator iterator = listaProfessores.iterator(); iterator.hasNext();){
                    
                    Professor professor = (Professor) iterator.next();                                        
                        
                        lst.add(new SelectItem(professor.getId(), professor.getNome()));              
                    
                }                
        
        return lst;          
    }            

    public Integer getSelectTipoContrato() {
        return selectTipoContrato;
    }

    public void setSelectTipoContrato(Integer selectTipoContrato) {
        this.selectTipoContrato = selectTipoContrato;
    }

    public BigDecimal getValorDesconto() {
        return valorDesconto;
    }

    public void setValorDesconto(BigDecimal valorDesconto) {
        this.valorDesconto = valorDesconto;
    }

    public BigDecimal getValorEmprestimo() {
        return valorEmprestimo;
    }

    public void setValorEmprestimo(BigDecimal valorEmprestimo) {
        this.valorEmprestimo = valorEmprestimo;
    }

    public String getRelatorio() {
        return relatorio;
    }

    public void setRelatorio(String relatorio) {
        this.relatorio = relatorio;
    }

    public Integer getSelectedProfessor() {
        return selectedProfessor;
    }

    public void setSelectedProfessor(Integer selectedProfessor) {
        this.selectedProfessor = selectedProfessor;
    }

    public Boolean getReciboMes() {
        return reciboMes;
    }
    
    public void setReciboMes(Boolean reciboMes) {
        this.reciboMes = reciboMes;
    }

    public Boolean getReciboPeriodo() {
        return reciboPeriodo;
    }

    public void setReciboPeriodo(Boolean reciboPeriodo) {
        this.reciboPeriodo = reciboPeriodo;
    }

    public String getTipoRecibo() {
        return tipoRecibo;
    }

    public void setTipoRecibo(String tipoRecibo) {
        this.tipoRecibo = tipoRecibo;
        
        if(this.tipoRecibo.equals("mes")){
            this.reciboMes = true;
            this.reciboPeriodo = false;
        }else{
            this.reciboMes = false;
            this.reciboPeriodo = true;            
        }
        
    }
    
    public Integer getMesFiltro() {
        return mesFiltro;
    }

    public void setMesFiltro(Integer mesFiltro) {
        this.mesFiltro = mesFiltro;
    }

    public Integer getSelectedProfessorDisciplina() {
        return selectedProfessorDisciplina;
    }

    public void setSelectedProfessorDisciplina(Integer selectedProfessorDisciplina) {
        this.selectedProfessorDisciplina = selectedProfessorDisciplina;
    }

    public Date getHorasAtraso() {
        return horasAtraso;
    }

    public void setHorasAtraso(Date horasAtraso) {
        this.horasAtraso = horasAtraso;
    }

    public String getTipoPonto() {
        return tipoPonto;
    }

    public void setTipoPonto(String tipoPonto) {
        this.tipoPonto = tipoPonto;
        
        if(this.tipoPonto.equals("mes")){
            this.pontoMes = true;
            this.pontoPeriodo = false;
        }else{
            this.pontoMes = false;
            this.pontoPeriodo = true;            
        }        
        
    }

    public Boolean getPontoMes() {
        return pontoMes;
    }

    public void setPontoMes(Boolean pontoMes) {
        this.pontoMes = pontoMes;
    }

    public Boolean getPontoPeriodo() {
        return pontoPeriodo;
    }

    public void setPontoPeriodo(Boolean pontoPeriodo) {
        this.pontoPeriodo = pontoPeriodo;
    }

    public Integer getMesFiltroPonto() {
        return mesFiltroPonto;
    }

    public void setMesFiltroPonto(Integer mesFiltroPonto) {
        this.mesFiltroPonto = mesFiltroPonto;
    }

    /**
     * @return the selectedDisciplina
     */
    public Integer getSelectedDisciplina() {
        return selectedDisciplina;
    }

    /**
     * @param selectedDisciplina the selectedDisciplina to set
     */
    public void setSelectedDisciplina(Integer selectedDisciplina) {
        this.selectedDisciplina = selectedDisciplina;
    }
    
}